use std::{
    collections::HashMap,
    error::Error,
    sync::mpsc::{self, Receiver, Sender},
    sync::Arc,
    sync::Mutex,
};

use crate::{domain::order_do::OrderUpdateDO, service::handler};

/**
 * 批量订单更新,包括买卖盘,取消订单,取消超时订单,用户下单,买卖盘批量下单.
 * @param symbol
 * @param matchingRequests
 */
pub fn on_order_update(order: OrderUpdateDO) -> Result<String, String> {
    handler::handle(order)
}

// pub fn on_order_update(order: OrderUpdateDO) -> Result<String, String> {
//     //如果匹配引擎内没有对应的市场,则加在市场
//     let order_symbol = order.get_symbol();
//     let symbol = match order_symbol {
//         None => {
//             // Err(String::from("symbol不存在"))
//             return Err("symbol不存在".to_string());
//         }
//         Some(s) => s.clone(), // Ok("symbol不存在".to_string())
//     };
//     let mut em=ENGINE_MAP.lock().unwrap();
//     let e: Option<&Engine> = em.get(symbol.as_str());
//     ///检查引擎是否存在,如果没有,则根据symbol创建一个撮合引擎出来.
//     // if let None = e {
//     //     //没有引擎,创建引擎
//     //     let engine = Engine::new(symbol.to_string());
//     //     em.insert(symbol, engine);
//     // };
//     // let mut em = ENGINE_MAP.lock().unwrap();
//     //如果没有对应engine,则创建engine
//     if false == em.contains_key(symbol.clone().as_str()) {
//         let (tx, rx) = mpsc::channel();
//         em.insert(
//             symbol.clone(),
//             Engine::new(symbol.clone(),rx),
//         );
//         // SENDER_MAP.insert(symbol.clone(), Mutex::new(tx));
//     }
//     // let sender = SENDER_MAP.get(symbol.as_str()).unwrap();
//     // sender.lock().unwrap().send(order).unwrap();
//     //开始发送订单到engine中去执行的并行执行器去执行.
//     return Ok("success".to_string());
// }

//      public Mono<Void> onOrderUpdate(Flux<OrderUpdateRequest> matchingRequests) {
//         //如果匹配引擎内没有对应的市场,则加在市场
// //        if (!matchingEngineInstMap.containsKey(symbol)) {
// //
// //        }

//         return matchingRequests.doOnNext(r->{
//         	String symbol = getSymbol(r);
//         	MatchingEngine matchingEngine = getMatchingEngine(symbol);
//         	if(matchingEngine==null) {
//         		log.warn("找不到对应的matchEngine,symbolIs:{}",symbol);
//         		return;
//         	}
//         	if (StringUtils.equalsAny(r.getAction(),
//                     OrderUpdateRequest.Action_Create,OrderUpdateRequest.ACTION_REMATCH)) {
//         		ExecutorService executorService = getExecutorService(symbol);
//                 executorService.execute(()->{
//                 	List<MatchResult> machResult = matchingEngine.putMatch(r);
//                 	tradeProcessor.submit(machResult);
//                 });
//             }else if (OrderUpdateRequest.Action_Cancel.equals(r.getAction())) {
//                 getExecutorService(symbol).execute(()->{
//                 	matchingEngine.removeOrder(r.getOrderId());
//                 });
//             }else if (OrderUpdateRequest.ACTION_CANCEL_OVERTIME_ROBOT.equals(r.getAction())) {
//             	Long passTimeSeconds = r.getPassTimeSeconds();
//             	//60需要定义为常量
//             	getExecutorService(symbol).execute(()->{
//             		matchingEngine.removeOverPassTimeOrder(passTimeSeconds);
//             	});
//             }
//         })
//         .doOnError(e->{
//         	log.info("订单update错误.",e);
//         })
//         .then();
//     }
#[cfg(test)]
mod test_order_update {
    use std::collections::HashMap;

    use async_std::task;

    use crate::domain::order_do::OrderUpdateDO;

    use super::on_order_update;

    #[test]
    pub fn test_symbol_error() {
        let o = OrderUpdateDO {
            action: "place".to_string(),
            order_id: "123456".to_string(),
            user_id: 10000,
            side: "buy".to_string(),
            order_type: "limit".to_string(),
            base_asset: "".to_string(),
            quote_asset: "".to_string(),
            price: 10000.0,
            quantity: 2.0,
            original_quantity: 2.0,
            order_time: 546544221544,
            version: 0,
            via: "".to_string(),
            symbol: "".to_string(),
            pass_time_seconds: -1,
            is_batch_order_end: false,
        };
        let result = on_order_update(o);
        println!("result is:{:?}", result);
        assert_eq!(Err("symbol不存在".to_string()), result)
    }
}
